package lanqiao._02算法训练.page02;

import java.util.*;

/**
 * @author 挚爱之夕
 * @version 1.0
 * @implSpec
 * 问题描述
 * 　　强大的kAc建立了强大的帝国，但人民深受其学霸及23文化的压迫，于是勇敢的鹏决心反抗。
 * 　　kAc帝国防守森严，鹏带领着小伙伴们躲在城外的草堆叶子中，称为叶子鹏。
 * 　　kAc帝国的派出的n个看守员都发现了这一问题，第i个人会告诉你在第li个草堆到第ri个草堆里面有人，要求你计算所有草堆中最少的人数，以商议应对。
 * 　　“你为什么这么厉害”，得到过kAc衷心赞美的你必将全力以赴。
 * 输入格式
 * 　　第一行一个数字n，接下来2到n+1行，每行两个数li和ri，如题。
 * 输出格式
 * 　　输出一个数，表示最少人数。
 * 样例输入
 * 5
 * 2 4
 * 1 3
 * 5 7
 * 1 8
 * 8 8
 * 样例输出
 * 3
 * 数据规模和约定
 * 　　30%的数据n<=10
 * 　　70%的数据n<=100
 * 　　100%的数据n<=1000
 * 　　所有数字均在int表示范围内
 * 思路：
 * 按左端点升序排，如果左端点相同，按右端点升序排
 * 取第一个区间作为当前区间cur
 * 与剩下的区间比较，有3中情况需要考虑：
 * 1.cur区间 包含next区间
 *  cur = next 缩短区间范围，cur区间至少有一个敌人
 * 2.两区间相交
 *  cur = 两相交的区域 缩短区间范围，cur区间至少有一个敌人
 * 3.两区间不相交
 *  cur 有至少有一个敌人， cur = next 继续
 * @since 2022 - 11 - 07 - 22:13
 */
public class _17隐匿的刺客 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] intervals = new int[n][2];
        for(int i = 0; i < n; i++){
            intervals[i][0] = sc.nextInt();
            intervals[i][1] = sc.nextInt();
        }
        Arrays.sort(intervals, (e1,e2)->e1[0]==e2[0] ? e1[1]-e2[1] : e1[0]-e2[0]);
        int cnt = 0;
        int[] cur = intervals[0];
        for(int i = 1; i < n; i++){
            int[] next = intervals[i];
            if(next[1] <= cur[1]){
                cur = next;
            }else if(cur[1] >= next[0]){
                cur = new int[]{next[0], cur[1]};
            }else if(next[0] > cur[1]){
                cur = next;
                cnt++;
            }
        }
        System.out.println(cnt+1);
    }
}
class Main_17{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if(n == 0 || n == 1){
            System.out.println(n);
            return;
        }
        List<int[]> list = new LinkedList<>();
        for(int i = 0; i < n; i++){
            int l = sc.nextInt();
            int r = sc.nextInt();
            list.add(new int[]{l, r});
        }
        //按左端点升序排，如果左端点相同，按右端点升序排
        list.sort((e1, e2) -> e1[0] == e2[0] ? e1[1] - e2[1] : e1[0] - e2[0]);

        int[] cur = list.get(0);
        int cnt = 0;
        for(int i = 1; i < list.size(); i++){
            int[] next = list.get(i);
            if(next[0] >= cur[0] && cur[1] >= next[1]){   //cur区间 包含next区间
                cur = next;
            }else if(next[0] < cur[1]){ //相交
                cur = new int[]{next[0], cur[1]};
            }else{  //不相交
                cur = next;
                cnt++;  //cur区间至少加一个敌人
            }
            //next区间 包含 cur区间 并不需要更新cur区间
        }
        //最后cur区间也要有一个敌人
        System.out.println(cnt + 1);
    }
}
class Main17_1{
    /**
     * 内部类 ——> 草堆
     * l ——> 左边界
     * r ——> 右边界
     */
    public static class Haystack {
        public int l;
        public int r;

        public Haystack(int l, int r) {
            this.l = l;
            this.r = r;
        }

        public int getR() {
            return r;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //n个看守员
        int n = sc.nextInt();
        //草堆集合
        List<Haystack> haystacks = new ArrayList<>();
        int l, r;
        for (int i = 0; i < n; i++) {
            l = sc.nextInt();
            r = sc.nextInt();
            haystacks.add(new Haystack(l, r));
        }
        //按 ri 排序(升序)
        haystacks.sort(Comparator.comparing(Haystack::getR));
        //记录 n 个区间的交集
        List<Object> length = new ArrayList<>();
        int minr, k;
        while (haystacks.size() != 0) {
            Haystack haystack = haystacks.get(0);
            minr = haystack.r;
            length.add(minr);
            k = 0;
            l = haystack.l;
            while (minr >= l) {
                k += 1;
                if (k < haystacks.size()) {
                    l = haystacks.get(k).l;
                } else {
                    minr = -1;
                }
            }
            for (int i = k - 1; i >= 0; i--) {
                haystacks.remove(i);
            }
        }
        System.out.println(length.size());
    }
}